package com.xwb.laboratory.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ThreadPoolDemo {

	public static void main(String[] args) throws InterruptedException {
		ThreadPoolDemo tpd = new ThreadPoolDemo();
		tpd.test1();
		
	}
	
	void testSchedule() throws InterruptedException {
		ScheduledExecutorService ses = Executors.newScheduledThreadPool(15);
		Runnable r = () -> {
			System.out.println("定时执行开始  " + System.currentTimeMillis());
			try {
				Thread.sleep(3000L);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("定时执行结束" + System.currentTimeMillis());
		};
		ses.scheduleAtFixedRate(r, 0, 1, TimeUnit.SECONDS);
		
		int i = 1;
		while(i < 15) {
			Thread.sleep(1000L);
			System.out.println(i++ + "秒");
		}
		ses.shutdownNow();
	}
	
	public void test4_SynchronousQueue() throws InterruptedException {
        // SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。
        // 它维护一组线程，这些线程在等待着把元素加入或移出队列。

        //put() 往queue放进去一个element以后就一直wait直到有其他thread进来把这个element取走。
        //take() 取出并且remove掉queue里的element（认为是在queue里的。。。），取不到东西他会一直等。

        final SynchronousQueue<String> queue = new SynchronousQueue<String>();

        new Thread(new Runnable() {
            public void run() {
                try {
                    System.out.println("before put...");
                    queue.put("a element");
                    System.out.println("after put...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();


        Thread.sleep(100L);

        new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(3000);

                    System.out.println("before take...");
                    String takedValue = queue.take();
                    System.out.println(takedValue);
                    System.out.println("after take...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
	
	void test1() {
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
				5,      //核心线程数
				10,     //最大线程数
				5,      //keepAliveTime，超过核心线程数的线程，超过 keepAliveTime
				TimeUnit.SECONDS,     //keepAliveTime的单位
				new LinkedBlockingQueue<>(10)    //工作队列，线程池执行的任务将会放到这个队列中
		);
		// 创建一个要执行的任务
		Callable<String> c = () -> {
			// 做些什么事
			Thread.sleep(3000L);
			return "任务执行结果";
		};
		
		// 任务集合
		List<Callable<String>> list = new ArrayList<>();
		
		// 往集合中放入任务
		list.add(c);
		
		// 执行任务
		try {
			List<Future<String>> futureList = threadPoolExecutor.invokeAll(list);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}
